package files;

import java.util.ArrayList;
import java.util.Hashtable;
import java.util.Map.Entry;
import java.util.TreeMap;

import polarity.Polarity;

import classifier.Classifier;
import classifier.ClassifierManager;

import tools.Writer;

public class TweetManager {

	static int count = 0;
	
	private static ArrayList<Tweet> alTweetTest = new ArrayList<Tweet>();
	private static ArrayList<Tweet> alTweetTrain = new ArrayList<Tweet>();
	private static ArrayList<Tweet> alTweetResultat = new ArrayList<Tweet>();
	
	public static ArrayList<Tweet> getAlTweetTest() {return alTweetTest; }
	public static ArrayList<Tweet> getAlTweetTrain() {return alTweetTrain; }
	
	private TweetManager() { }
	
	public static void addTweetTest(Tweet tweetTest)
	{
		System.out.println(count);
		alTweetTest.add(tweetTest);
		
		ClassifierManager.setTweetTestClassifier(tweetTest);
		
		tweetTest.calculateBayesMultinomial();
		count++;
	}
	
	public static void addTweetResultat(Tweet tweetResultat) 
	{
		alTweetResultat.add(tweetResultat);
	}
	
	public static void addTweetTrain(Tweet tweetTrain)
	{
		alTweetTrain.add(tweetTrain);
	}
	
	/*
	public static void calculateBayesMultinomial()
	{
		for(int i=0; i<alTweetTrain.size();i++)
		{
			alTweetTrain.get(i).calculateBayesMultinomial();
		}
	}
	*/
	
	public static void readingResultatFinish() 
	{
		double score = 0;
		int nbrTweet = alTweetTest.size()+1;
		int nbrTweetReussi = 0;
		for(int i=0;i<alTweetTest.size();i++)
		{
			System.out.println("Ligne "+i+" : "+alTweetTest.get(i).getType()+" - "+alTweetResultat.get(i).getType());
			if ( alTweetTest.get(i).getType().equals(alTweetResultat.get(i).getType()) )
			{
				nbrTweetReussi++;
			}
		}
		System.out.println("SCORE");
		System.out.println("nbrTweet : "+nbrTweet);
		System.out.println("nbrTweetReussi : "+nbrTweetReussi);
		System.out.println("Pourcentage : "+nbrTweetReussi*100/nbrTweet);
		
		
	}
	
	public static void readingTestFinish() 
	{
		String string = "";
		for(int i=0;i<alTweetTest.size();i++)
		{
			Tweet tweet = alTweetTest.get(i);
			//string += "("+tweet.getType()+","+tweet.getMark()+") "+tweet.getContent()+"\n";
			string += tweet.getType()+"\n";
		}
		Writer.writeResult("resultat.txt", string);
	}
	
	public static void calculateBayesMultinomial() 
	{
		
		/*** Verison 1 ***/
//		ClassifierManager.getClassifierGeneral();
//		TreeMap<String, Integer> vocabularyAll = ClassifierManager.getClassifierGeneral().getVocabularyGeneral();
//		for(Entry<String, Integer> set : vocabularyAll.entrySet() )
//		{
//			ArrayList<Classifier> alClassifier =  ClassifierManager.getClassifierAl();
//			for(int i=0;i<alClassifier.size();i++)
//			{
//				Classifier classifierTmp = alClassifier.get(i);
//				ArrayList<TreeMap<String, Integer>> alVocabulary = classifierTmp.getVocabularyWordCountAl();
//				ArrayList<TreeMap<String, Float>> alBayes = classifierTmp.getBayesAl();
//				for(int j=0;j<alVocabulary.size();j++)
//				{
//					TreeMap<String, Integer> vocabularyTmp = alVocabulary.get(j);
//					TreeMap<String, Float> bayesTmp = alBayes.get(j);
//					if ( vocabularyTmp.containsKey(set.getKey()))
//					{
//						float value = (float) ((vocabularyTmp.get(set.getKey())+1.00)/(classifierTmp.getNumberOfWords()+classifierTmp.getNumberOfDifferentWords()));
//						bayesTmp.put(set.getKey(), value);
//					}
//					else
//					{
//						float value = (float)(1.00)/(classifierTmp.getNumberOfWords()+classifierTmp.getNumberOfDifferentWords());
//						bayesTmp.put(set.getKey(), value);
//					}
//				}
//				 
//				
//				 // Nombre de fois que le mots apparait ds la classe
//				 // Nombre de mots ds le voc
//				 // Nombre de mots differents
//				 
//			 }
//			
//		}
		/*** Version 2 ***/
		TreeMap<String, Integer> vocabularyAll = ClassifierManager.getClassifierGeneral().getVocabularyGeneral();
		// Pour chaque mots
		for(Entry<String, Integer> entryVocabulary : vocabularyAll.entrySet() )
		{
			Hashtable<String, Classifier> classifierHt = ClassifierManager.getClassifierHt();
			// Pour chaque Classifieur
			for(Entry<String, Classifier> entryClassifier : classifierHt.entrySet() )
			{
				Hashtable<String, Polarity> polarityHt = entryClassifier.getValue().getPolarityManager().getPolarityHt();
				// Pour chaque Polarite
				for(Entry<String, Polarity> entryPolarity : polarityHt.entrySet() )
				{
					TreeMap<String, Integer> vocabulary = entryPolarity.getValue().getVocabulary();
					TreeMap<String, Float> bayes = entryPolarity.getValue().getBayes();
					
					
					
					
					float value;
					if ( vocabulary.containsKey(entryVocabulary.getKey()))
					{
						value = (float) ((vocabulary.get(entryVocabulary.getKey())+1.00)/(entryPolarity.getValue().getNumberOfWords()+ entryClassifier.getValue().getPolarityManager().getNumberOfDifferentWords()));
						bayes.put(entryVocabulary.getKey(), value);
					}
					else
					{
						value = (float)(1.00)/(entryPolarity.getValue().getNumberOfWords()+ entryClassifier.getValue().getPolarityManager().getNumberOfDifferentWords());
						bayes.put(entryVocabulary.getKey(), value);
						
					}
					/*
					if ( entryClassifier.getKey() == "microsoft" && entryPolarity.getKey() == "positive") 
					{
						System.out.println("Classifier "+entryClassifier.getKey());
						System.out.println("Polarite "+entryPolarity.getKey());
						System.out.println("Mot "+entryVocabulary.getKey());
						System.out.println(entryClassifier.getValue().getPolarityManager().getNumberOfDifferentWords());
						System.out.println("Value "+value);
					}
					*/
					
				}
			}
		}
	}
	
	
	
}
